[第4波]幽魂系列汉化的有关资料

shane007

最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
+ l2 g: x* O8 f1 u0 F也许将来可以用于汉化。

和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html
' d3 ~" R! j$ p8 ?  p" x8 M! L
相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
-----------------------------------------------------------------------
2012/1/2  更新
关于幽魂游戏的字幕
4 m3 d. O* ]; X# k, ~( SPhantasmagoria subtitles function discovered - ScummVM :: Forums
' t) ~9 n, M# T: |7 A
. G! P( q# W" A' F( V6 aVMD文件
Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki

字幕
8 [% C% Q7 {4 j' Z# CSubtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)
; o8 i/ D/ d% N4 |
FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

1. /*
   
2. * subtitle-rbt.c
   , O4 W! d# F4 G# C  \$ b1 [' g" M
3. *  by Mike Melanson (mike -at- multimedia.cx)
   
4. *
   
5. * build with this command:
   # u* c2 k5 t& {
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   
7. */
   & v/ ^1 }. X  P% g2 U+ S2 g
8. 
     z9 [' V* v7 L( s: ]* N" v* _* y" L
9. #include <inttypes.h>
   - M! F1 P. }* v, ^
10. #include <math.h>
    / f+ `$ d- v7 M1 K2 j
11. #include <stdio.h>
    
12. #include <stdlib.h>
    : y( k9 Q4 a$ P  p6 J, ?# |
13. #include <string.h>
    + V( N! y0 m/ o7 s) Z9 b
14. 
    $ `0 E4 h9 c% y* F2 i  v
15. #include <ass/ass.h>
    
16. 
    
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    9 N. [# R' C& W* ]6 B$ F
18. 
    " C, U% r) {. K  P; Z& Q  \
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    3 _0 q( m% ]( O$ h; Q1 R
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    8 |2 E; I0 k( m5 Y
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    
23. 
    
24. /*********************************************************************/
    1 T; B+ C" S3 e- P
25. 
    , |! m2 X8 A# Z, S! S
26. /* Bit reader stuff */
    
27. 
    $ W/ I8 M" Y! C( D
28. typedef struct
    & @% `. i' x: Z3 g+ l- A% q
29. {
    7 ^- q7 p7 T8 j/ ^! X' x- [; Z4 b! _& ^
30.     uint8_t *bytestream;
    
31.     int bytestream_size;
    " D4 H  x$ N2 `" M. d* o
32.     int index;
    . m5 d+ E( z2 Y4 R3 Y$ d. I
33.     uint32_t bits;
    9 b' Z" x0 w9 V8 A# n
34.     int bits_in_buffer;
    % j* `* V9 g6 K  E3 y2 T
35. } get_bits_context;
    
36. 
    
37. static inline void reload_bits(get_bits_context *gb)
    
38. {
    7 Y: \7 n- b9 g! Y  G1 t* d
39.     while (gb->bits_in_buffer <= 24)
    : b3 I0 g3 k- b, b, Y6 b
40.     {
    
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    
43.         gb->bits_in_buffer += 8;
    ; B! a9 m2 O) a5 e; a6 _
44.     }
    1 K+ Y# @% A* K
45. }
    $ l. q( z9 P# ]4 a& ?- x1 k/ f5 x; h
46. 
    
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    ' K$ a: l/ U- _. t# r% M$ v9 L2 x. h
48. {
    , h( ]7 @7 k, p! @
49.     gb->bytestream = malloc(size);
    
50.     memcpy(gb->bytestream, bytestream, size);
    
51.     gb->bytestream_size = size;
    
52.     gb->index = 0;
    / R  u# f' i4 h+ u5 _
53.     gb->bits = 0;
    
54.     gb->bits_in_buffer = 0;
    4 }  L4 f1 {5 f7 l* n
55. 
    ' B. }' B4 S2 I1 s3 V1 F0 b$ Z4 ]
56.     reload_bits(gb);
    
57. }
    
58. 
    
59. /* read bits without consuming them from the stream */
    & Q4 `5 O3 n" r. v8 A. B
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    
62.     if (count >= 24)
    
63.         return -1;
    
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    
66.     return (gb->bits >> (32 - count));
    
67. }
    ) {5 L: J# @* D: F9 r
68. 
    
69. /* read and consume bits from the stream */
    
70. static int read_bits(get_bits_context *gb, int count)
    % g8 E. _- w8 N' j/ m! s
71. {
    
72.     int value;
    
73. 
    9 d( i0 m" [! o: s4 u: w: b) T
74.     if (count >= 24)
    ; ~- c; o0 }1 z1 X1 z' J& C# Y3 ?
75.         return -1;
    ) |, S! a4 h% V6 T' {
76. 
    
77.     value = view_bits(gb, count);
    0 r& N$ t/ @/ K
78.     gb->bits <<= count;
    ( x# w! }' K( G$ ^  K/ U
79.     gb->bits_in_buffer -= count;
    
80. 
    # O- W0 v- l' d0 m' ]7 R$ x  c' H
81.     return value;
    - v& a1 S; e! G: Q8 S9 u1 _' n
82. }
    3 G7 a; Y4 ^/ P; r8 n$ K0 g. o: X
83. 
    ; G; f: ]# T' O  N& R! N' ^
84. static void delete_get_bits(get_bits_context *gb)
    
85. {
    # x1 {- E- N- U
86.     free(gb->bytestream);
    
87. }
    ( d) ]! h' H6 Y9 o
88. 
    
89. /*********************************************************************/
    9 X" s) a. f/ o: B" e- |+ A
90. 
    ; O7 A. F/ V: B0 s' z1 t' D+ `  x
91. /* Bit writer stuff */
    2 R! Q' x2 Z$ r- h# w& |0 z
92. 
    
93. #define MAX_PUT_BITS_BYTES 63000
    4 w7 e5 D5 c% X, Q
94. typedef struct
    
95. {
    ( f& K" H" H# n) i; Q, [
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    # n, k5 I5 l* \" M  ]
97.     int byte_index;
    9 d4 r: L" \' J5 j+ d# c
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
    
100. } put_bits_context;
     9 n  X/ O, Z1 m+ S/ R' K- @* x
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     & q7 f; f+ O( P; V
103. {
     
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     
107.     pb->bits_buffered = 0;
     ; E$ A1 S5 a, i' b# C
108. }
     
109. 
     8 d4 h6 J" L% L* D
110. static put_bits_context *init_put_bits()
     
111. {
     
112.     put_bits_context *pb;
     
113. 
     . A/ h/ `. i, _' x2 l* K) Y6 [
114.     pb = malloc(sizeof(put_bits_context));
     
115.     reset_put_bits(pb);
     
116. 
     4 X1 \3 L& s+ V8 k
117.     return pb;
     
118. }
     $ D) J( k4 |/ n/ w: M5 @
119. 
     
120. static void put_bits(put_bits_context *pb, int bits, int count)
     
121. {
     
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     
124.     pb->bits_buffered += count;
     
125. 
     , Z2 G. s2 l2 Y8 q" Z! F
126.     while (pb->bits_buffered >= 8)
     
127.     {
     
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     - q' F* c5 W9 q$ h: Z( i5 c
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
     ( T7 D9 {  R" X  i
131.     }
     
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     
134.     {
     
135.         printf("HELP! Bit overflow\n");
     ! s6 i! K$ r+ L( u
136.         exit(1);
     
137.     }
     
138. }
     * w7 n9 w' ~* o! d& n$ Y9 ?# l" E
139. 
     0 A& L( N9 n, m4 L8 F
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     
142.     if (pb->bits_buffered > 0)
     & u8 v( J9 J7 }" \
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     " o3 r/ w) C. b7 o" C
144. }
     3 M* z  \& j3 a$ H( h* C6 |: F
145. 
     , t* g$ z/ q. r: J6 M& C. P* O
146. static void delete_put_bits(put_bits_context *pb)
     
147. {
     
148.     free(pb->bytes);
     
149. }
     0 d$ y( _1 E3 a! x3 ^
150. 
     - N3 T$ t; S; Z- _4 y  r& x' `+ j
151. /*********************************************************************/
     
152. 
     
153. /* RBT functions */
     
154. 
     
155. #define PALETTE_COUNT 256
     & Y* c4 F; R* Y& u2 D
156. #define RBT_HEADER_SIZE 60
     
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     8 K1 ?/ ^- E# ^9 J  m; B
158. #define SUBTITLE_THRESHOLD 0x70
     - r" c! b) f8 s7 ^0 T
159. #define MILLISECONDS_PER_FRAME 100
     
160. 
     
161. /* VLC table */
     / M# _, ]) p/ [$ {) L6 h) f
162. #define VLC_SIZE 4
     
163. static struct
     2 f( c, j% {; t$ {8 s* E
164. {
     2 x: i! F! ?! k( Z  x* g0 T
165.     int count;
     
166.     int value;
     
167. } lzs_vlc_table[] =
     
168. {
     
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     9 q' q9 _) Q' G- p& @% E0 v4 e
171.     /* 0001 */ { 2, 2 },
     
172.     /* 0010 */ { 2, 2 },
     % C- Q3 S. Q! x  m6 {1 R/ ]
173.     /* 0011 */ { 2, 2 },
     # X3 \0 l5 Q! }$ _6 e% n1 l
174. 
     6 i$ T  Q# e" j4 J6 Z$ s
175.     /* code length = 2 bits; value = 3 */
     
176.     /* 0100 */ { 2, 3 },
     
177.     /* 0101 */ { 2, 3 },
     $ I& m" z' b% _
178.     /* 0110 */ { 2, 3 },
     
179.     /* 0111 */ { 2, 3 },
     
180. 
     
181.     /* code length = 2 bits; value = 4 */
     # l6 L# u$ G  B
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     - k* V0 n; O; {. E4 \
184.     /* 1010 */ { 2, 4 },
     
185.     /* 1011 */ { 2, 4 },
     2 ^% |8 }# e5 m: L% \9 D  L& H" c
186. 
     
187.     /* code length = 4 bits; value = 5 */
     
188.     /* 1100 */ { 4, 5 },
     
189. 
     # s0 h  U+ n* u& t7 H; X* ^
190.     /* code length = 4 bits; value = 6 */
     
191.     /* 1101 */ { 4, 6 },
     
192. 
     ( ]( w: E) L# g$ q, F' }
193.     /* code length = 4 bits; value = 7 */
     
194.     /* 1110 */ { 4, 7 },
     
195. 
     
196.     /* special case */
     
197.     /* 1111 */ { 4, 8 }
     6 e, X" g' `& @) j2 L
198. };
     " j5 p' e+ x: |- [6 Q; z+ ^
199. 
     8 m. W$ M, @, D
200. typedef struct
     
201. {
     
202.     int version;
     # T6 D  B7 G/ I# D
203.     int width;
     1 f- r/ [0 X6 q
204.     int height;
     6 ]$ D& _; e  c' j$ F% L
205.     int frame_count;
     
206.     int audio_chunk_size;
     5 E5 P" n6 \4 I# Z4 a
207.     uint8_t palette[PALETTE_COUNT * 3];
     0 n# u' u) ~5 K
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     
210.     off_t frame_size_table_offset;
     : \1 Q! m/ \+ G0 T: o& O7 i: C
211.     uint8_t *frame_size_table;
     0 i( b$ Q. J* t; H+ ~3 R
212.     uint8_t *frame_load_buffer;
     
213.     int dump_frames;
     
214. 
     
215.     /* subtitle library */
     
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
     ' r5 g" L) g8 P, b# k$ k
218.     ASS_Track *ass_track;
     - M9 f$ `3 ?: D: H$ @
219. } rbt_dec_context;
     0 r* E; Y- r* @7 R8 [& }  z
220. 
     7 [5 d$ N2 r" e; w4 y# Y1 E8 m. |( r
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     
222.     uint8_t *image, int width, int height)
     
223. {
     
224.     FILE *outfile;
     
225.     uint8_t bytes[3];
     
226.     int p;
     " m+ J3 t; N0 h
227.     uint8_t pixel;
     8 G7 y; T: f$ X" S& K/ X
228. 
     1 E8 J) \( X$ I
229.     outfile = fopen(filename, "wb");
     
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     3 L, z+ Z! V, y, F) S9 B$ N
231.     for (p = 0; p < width * height; p++)
     - f9 f" K7 Z2 [: g* F' T
232.     {
     
233.         pixel = image[p];
     
234.         bytes[0] = rbt->palette[pixel*3+0];
     
235.         bytes[1] = rbt->palette[pixel*3+1];
     
236.         bytes[2] = rbt->palette[pixel*3+2];
     ) C0 h& e& _3 O: p! r
237.         fwrite(bytes, 3, 1, outfile);
     
238.     }
     
239.     fclose(outfile);
     8 l" b/ ^4 I" K+ P' U% u4 k
240. }
     : m/ t0 p0 W9 Z+ B0 m- m
241. 
     * M0 ~, X) R% @, N# v
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     ) z) r& f3 {+ u3 o* u
243. {
     
244.     uint8_t header[RBT_HEADER_SIZE];
     
245.     int palette_data_size;
     ( }8 d- m, ~- S* \1 l. U% ]  U/ N
246.     uint8_t *palette_chunk;
     
247.     int unknown_chunk_size;
     : M" e7 e. S# N3 Y
248.     uint8_t *unknown_chunk;
     
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     
250.     off_t padding_size;
     
251.     uint8_t *padding;
     
252.     int i;
     
253.     int frame_size;
     3 d1 c; h- L0 k
254.     int max_frame_size;
     
255.     int first_palette_index;
     ) q( G8 f  S5 |! w
256.     int palette_count;
     
257.     int palette_type;
     5 m6 R" ~0 {5 s4 c1 {2 N
258.     int palette_index;
     
259. 
     $ D% ?! q/ n1 M: {( K
260.     fseek(inrbt_file, 0, SEEK_SET);
       G( G& I9 i1 t
261.     fseek(outrbt_file, 0, SEEK_SET);
     4 s9 X2 T' l) L
262. 
     
263.     /* load the header */
     
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     
265.     {
     
266.         printf("problem reading initial RBT header\n");
     ; [7 k3 b- L6 N; R) @% w2 P/ V
267.         return 0;
     
268.     }
     
269. 
     
270.     /* copy header to the output */
     
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     0 [" X& e& c0 \& G* J0 P, L
272.     {
     : d5 ?8 G7 c! U1 V% P
273.         printf("problem writing initial RBT header\n");
     
274.         return 0;
     
275.     }
     
276. 
     
277.     rbt->version = LE_16(&header[6]);
     
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     ' z1 _, n1 j! Y: N: Y, Y$ Q- f* E
279.     rbt->frame_count = LE_16(&header[14]);
     1 V" D1 n0 y% w2 _8 j) T6 a' Q  E
280. 
     
281.     /* transfer the unknown data, if it's there */
     
282.     unknown_chunk_size = LE_16(&header[18]);
     
283.     if (unknown_chunk_size > 0)
     
284.     {
     # f( n. E+ g  X2 q& m3 S0 T
285.         unknown_chunk = malloc(unknown_chunk_size);
     * J/ P" f( ?( R. W# d2 S
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     
287.         {
     
288.             printf("problem reading unknown data\n");
     $ u5 Z/ Q( T6 O) b9 e1 t2 s
289.             return 0;
     
290.         }
     
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     
292.         {
     , ?( f  j7 j! Q& `% `
293.             printf("problem writing unknown data\n");
     2 B7 f; V9 C. o- E/ v6 x" y/ h; R
294.             return 0;
     1 ?5 x2 _# R* \3 B
295.         }
     # {* S4 M( @( o
296.         free(unknown_chunk);
     2 }  `. D, {4 s. l
297.     }
     - A/ g2 \; @' U3 L; P( s/ R
298. 
     
299.     /* transfer the palette chunk */
     : j& `% g1 N6 q) w; O, M
300.     palette_data_size = LE_16(&header[16]);
     
301.     palette_chunk = malloc(palette_data_size);
     
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     4 [0 `6 [8 E7 U1 J( O
303.     {
       j( \, O, h; W, ^, J
304.         printf("problem reading palette\n");
     
305.         return 0;
       i3 m) y  t2 ?% [/ V& @# D6 J
306.     }
     
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     & `3 W, u# H8 l" l& W
308.     {
     & ~" r& G# U9 Q* y" ]7 }/ C8 M
309.         printf("problem writing palette\n");
     * E% L- z! j6 j, R# W
310.         return 0;
     1 i! {6 I2 X7 q6 g
311.     }
     
312.     /* load the palette into the internal context */
     2 K" N) h( u0 z
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     6 P0 J' n+ L- H/ N% y
314.     first_palette_index = palette_chunk[25];
     
315.     palette_count = LE_16(&palette_chunk[29]);
     
316.     palette_type = palette_chunk[32];
     # Q: S1 g, A- Y5 y! z7 ]2 N6 q+ |% f0 R
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     
319.     {
     ' o6 S! R0 W; W8 o4 V9 o
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     # r/ n& W$ s. |) Q
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     
323.     }
     - L4 V# a4 C# o& ~
324.     free(palette_chunk);
     
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     8 U3 ~! ?! B& A
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     : k5 I$ g  A3 v; D- U
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
329.     {
     0 g: L4 e& K3 H) r8 C  b
330.         printf("problem reading frame table\n");
     
331.         return 0;
     : Y, ]* V! l: ]" f' o2 i8 r
332.     }
     / l4 a# W6 k1 [
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     4 E7 b% v. _% k: |
335.     {
     
336.         printf("problem writing frame table\n");
     
337.         return 0;
     9 W! v9 t7 Z4 c7 [6 S& m6 u
338.     }
     
339. 
     
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     0 }% [" s; M4 y3 G
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     ! k9 F. }$ o' k* I
343.     {
     
344.         printf("problem reading frame table\n");
     ; o% S, S) z2 J2 O/ I- N* ^# @
345.         return 0;
     1 A- i4 x- {% i' s- F3 K" P
346.     }
     ) [. L& e% j. V5 D8 _7 I/ X7 F
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
349.     {
     
350.         printf("problem writing frame table\n");
     
351.         return 0;
       u$ @$ A+ `: Q' [4 y) a! G4 p
352.     }
     , {, K4 b3 J/ ?, u$ ^6 i% q
353. 
     
354.     /* find the max frame size */
     
355.     max_frame_size = 0;
     
356.     for (i = 0; i < rbt->frame_count; i++)
     # @) e+ I- G1 J0 j/ D" _
357.     {
     
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
359.         if (frame_size > max_frame_size)
     - T. `- h1 Q4 {
360.             max_frame_size = frame_size;
     3 l* }; ]! f, I* ?
361.     }
     4 Q- ?. i( n! {: I6 r% I+ K
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     , b: l5 v1 t9 I$ `# t+ ?& N& [9 R
363. 
     / x8 a0 u0 f6 \' ~
364.     /* transfer the unknown table(s) */
     8 Y  r0 b' J! P1 f! M) ~% g' m
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     2 M  k- {) _) }$ X5 h
366.     {
     
367.         printf("problem reading unknown table\n");
     ' A. v  p- w" E1 e2 m& r
368.         return 0;
     8 W& J3 M1 O8 ]8 K9 ~. Y$ l
369.     }
     2 D6 V  A" q3 D' T
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     
371.     {
     
372.         printf("problem writing unknown table\n");
     
373.         return 0;
     * k! ^$ K+ k# I* H
374.     }
     ' g- g7 b5 R5 ?) h+ f
375. 
     3 V8 M+ ]! T2 c: V3 E
376.     /* copy over padding */
     ' F$ Q6 \4 J3 G: m
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     # a0 A% Q! _/ b- y
378.     if (padding_size)
     + P& T4 Q( v' ^
379.     {
     * r/ ?" x4 _" N% Z8 J$ E6 L0 q
380.         padding = malloc(padding_size);
     
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     
382.         {
     & h2 ~. y- ~7 ]% @" [4 m, @
383.             printf("problem reading padding\n");
     
384.             return 0;
     
385.         }
       l1 h5 ?( F$ z' L
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     
387.         {
     
388.             printf("problem writing padding\n");
     ) N2 x& l+ ?9 s
389.             return 0;
     
390.         }
     
391.         free(padding);
     
392.     }
     
393. 
     
394.     return 1;
     
395. }
     ! Z5 e- _9 U, v
396. 
     
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     4 O1 i7 Q" F, h( G! x$ A
399.     int vlc;
     
400.     int count;
     
401.     int value;
     & o. R8 Q- w8 B! h( s2 T
402. 
     
403.     vlc = view_bits(gb, VLC_SIZE);
     & M2 `% q+ J1 |, O8 K2 s
404.     count = lzs_vlc_table[vlc].count;
     % z  n* A- L4 h
405.     value = lzs_vlc_table[vlc].value;
     
406. 
     
407.     read_bits(gb, count);
     + K! ~1 ~; A! U$ X  [2 F
408.     if (value == 8)
     3 I8 E) `& }& I+ k+ P2 _8 B; ^
409.     {
     
410.         do
     + t) o- H; f+ V" O& n+ s6 ?
411.         {
     * m8 Q( C: y& r+ R8 G$ {. R+ e4 [7 Y
412.             vlc = read_bits(gb, VLC_SIZE);
     
413.             value += vlc;
     
414.         }
     
415.         while (vlc == 0xF);
     / J3 |5 {1 |) P) S2 F' o# W$ ~: w
416.     }
     - o( _: k% |$ O* [" H& g0 a
417. 
     $ }& L1 v$ O% w2 `3 m) Z6 Q% ~8 F1 M
418.     return value;
     
419. }
     ; R. ]& z0 ^) S; f- `% e0 T
420. 
     
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     
422.     int full_window_stride,
     
423.     int window_top, int window_bottom, int window_left, int window_right)
     ! {- [/ }/ [8 f) }! y% B8 @. G
424. {
     
425.     int last_pixel;
     # I* v0 h- ?- J5 k4 o9 o; ]
426.     int run_size;
     
427.     int x;
     
428.     int y;
     7 S  u5 k; k, {6 [3 J" U
429.     int start_index;
     
430.     int end_index;
     3 @& w8 p0 l, y
431.     int encode_last_run;
     
432. 
     8 ]1 D8 }. `; e/ T6 A# `3 Q
433.     last_pixel = full_window[0];
     
434.     run_size = 1;
     * x* Q5 ^: C, [7 }
435.     for (y = window_top; y <= window_bottom; y++)
     2 @7 U- D; x0 ~  \, t; ~
436.     {
     
437.         start_index = y * full_window_stride + window_left;
     
438.         if (y == window_top)
     
439.             start_index += 1;
     + F8 _9 M) t+ W; P# `
440.         end_index = y * full_window_stride + window_right;
     8 u6 m8 h/ v) A+ U6 I; L9 s
441.         if (y == window_bottom)
     
442.             encode_last_run = 1;
     " R6 Z1 Y/ t4 l' a
443.         else
     
444.             encode_last_run = 0;
     
445.         for (x = start_index; x < end_index; x++)
     
446.         {
     
447.             if (!encode_last_run && full_window[x] == last_pixel)
     * M. d& H& N8 H! o/ J! F
448.                 run_size++;
     
449.             else
     9 r: q3 b! X$ A' B5 E* @6 |$ Y
450.             {
     ) [' N: s) Q, X" u( B8 t1 I9 A
451.                 if (run_size == 1)
     4 u6 g6 U1 }9 t1 \6 d+ }
452.                 {
     
453.                     /* encode a 0 bit followed by raw pixel byte */
     & w& N: M) f. [4 W
454.                     put_bits(pb, 0, 1);
     
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     
457.                 else if (run_size == 2)
     & d" [. x  s) @3 b. h9 ~  E
458.                 {
     9 ~) M5 B8 Y! \3 I5 C6 T
459.                     /* encode a 0 bit followed by raw pixel byte */
     
460.                     put_bits(pb, 0, 1);
     0 v9 q& B, H, k: ?
461.                     put_bits(pb, last_pixel, 8);
     4 R( I( m* T) R8 T" [0 v' w
462.                     put_bits(pb, 0, 1);
     
463.                     put_bits(pb, last_pixel, 8);
     
464.                 }
     
465.                 else
     % ^" `2 b. J; X" q# M
466.                 {
     
467.                     /* encode a 0 bit followed by raw pixel byte */
     5 i* o. X% {( W6 ^
468.                     put_bits(pb, 0, 1);
     
469.                     put_bits(pb, last_pixel, 8);
     
470.                     run_size--;
     ! j- Z3 M) ^4 m6 O- m
471.                     /* encode a run: a 1 bit, followed by a back reference
     4 z5 w0 ?1 v% z' E' _  f
472.                      * offset (-1), followed by a length */
       q! D1 V- [. a. a; x
473.                     put_bits(pb, 1, 1);
     
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     9 W9 K1 D7 a- V
475.                     put_bits(pb, 1, 7);
     , R3 s9 ^; u8 l/ y- P
476.                     if (run_size <= 4)
     
477.                     {
     
478.                         /* lengths 2, 3, and 4 are 2 bits */
     & }+ C/ a1 S. j  P& i1 O
479.                         put_bits(pb, run_size - 2, 2);
     
480.                     }
     
481.                     else if (run_size <= 7)
     
482.                     {
     
483.                         /* lengths 5, 6, and 7 are 4 bits */
     8 \  H! ?- K! o: O5 _0 }9 s4 [0 A
484.                         put_bits(pb, run_size + 7, 4);
     
485.                     }
     
486.                     else
     9 L" C  `" B" ^: S8 j0 \
487.                     {
     6 s+ Z9 J4 t/ r0 U$ i- [
488.                         /* arbitrary length; start by encoding 0xF which
     
489.                          * stands in for an initial version of 8 */
     
490.                         put_bits(pb, 0xF, 4);
     
491.                         run_size -= 8;
     : C% J% x3 B( i' D0 x; l
492. 
     4 }$ S& U* ^# g+ q3 ~1 K
493.                         /* encode blocks of 4 bits until run_size is 0 */
     
494.                         while (run_size >= 0)
     " E( F+ F# r, `8 o+ b7 z
495.                         {
     
496.                             if (run_size >= 15)
     ( x% d( D8 z# g% H1 i
497.                             {
     ! i8 a! S. o: q  v, U9 M, l
498.                                 put_bits(pb, 0xF, 4);
     
499.                                 run_size -= 0xF;
     9 _0 E4 l9 _, w* U
500.                             }
     
501.                             else
     3 Z# g" S3 _+ u
502.                             {
     
503.                                 put_bits(pb, run_size, 4);
     ( ?5 ]4 W1 |$ v6 \  s
504.                                 run_size = -1;
     % v/ V% I6 r# |  W$ o4 y0 }; a
505.                             }
     ' A$ c! B7 ^& I3 B, B! b
506.                         }
     4 W' s5 ?" w) ]
507.                     }
     1 H9 v7 r0 |8 C# \3 F. q
508.                 }
     
509. 
     , H, }$ w$ u( l
510.                 last_pixel = full_window[x];
     - B; }* b2 Z- P7 L% m4 J2 F
511.                 run_size = 1;
     
512. 
     
513.                 /* this single x iteration was only here to close the final run */
     * h: ]- m" t8 x( t
514.                 if (y == window_bottom)
     
515.                     break;
     0 f, r4 P! J5 Y% V
516.             }
     0 J! E- e" f) Y! _
517.         }
     
518.     }
     
519. 
     
520.     /* close the bitstream by encoding a back reference with length 0 */
     4 I! T' o" p. O5 Z6 p
521.     put_bits(pb, 1, 1);  /* back reference run */
     . a( C& H0 ~; D  u# b; l# v3 [# J
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     + f0 V8 F# t" T* |% P' Z0 p. H
523.     put_bits(pb, 0, 7);  /* length 0 */
     
524. 
     ( h# x. |7 U4 O- O( {" U) Q2 O
525.     put_bits_flush(pb);
     
526. }
     
527. 
     0 K8 u& A& S9 e
528. /* compute Euclidean distance between an RGB color and the desired target */
     % L) D& e6 C) E& F* |1 f
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     
530. {
     $ ^7 ~& g; S$ t$ B8 ^
531.     return sqrt((r1 - r2) * (r1 - r2) +
     1 [3 T* G; R, X: c
532.                 (g1 - g2) * (g1 - g2) +
     / u( n- X8 @% X. F1 s! _
533.                 (b1 - b2) * (b1 - b2));
     % ^1 |( j( S2 N) t
534. }
     
535. 
     
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     ! ]# W) j5 V. w. q+ x
537. {
     ' _. C* O0 Q) `
538.     int i;
     " K  U9 C6 B) s& ]9 g+ [
539.     int nearest_distance;
     3 U' A% S4 U% f. J( D6 _
540.     int distance;
     
541.     int rp;
     
542.     int gp;
     # r8 ~2 |( n3 F. ^9 y
543.     int bp;
     
544.     uint8_t palette_index;
     
545. 
     ' n( o6 X" I/ i- s& N" \2 F1 O
546.     nearest_distance = 999999999;
     ) u9 {+ n7 K9 d" |) b
547.     palette_index = 0;
     
548.     for (i = 0; i < 256; i++)
     8 f% @$ M2 O4 p6 |8 ^- G4 n: L4 p
549.     {
     
550.         rp = rbt->palette[i * 3 + 0];
     
551.         gp = rbt->palette[i * 3 + 1];
     
552.         bp = rbt->palette[i * 3 + 2];
     
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     
554.         if (distance < nearest_distance)
     
555.         {
     6 n7 \6 r. D% H+ S+ ?& l) W9 q
556.             nearest_distance = distance;
     
557.             palette_index = i;
     $ ]" P- @# b4 x( M1 x7 ?) G( a
558.         }
     ' t" s3 i5 R7 ]# X9 E6 f* T: W7 a
559.         /* can't get closer than 0; break early */
     5 s) V' `  i  H5 S* k, e
560.         if (distance == 0)
     ' X$ [$ m8 f1 e7 b" N
561.             break;
     
562.     }
     
563. 
     4 [9 R; Q3 H% _
564.     return palette_index;
     
565. }
     + B+ _& ~# d" G: \$ {3 I& Y/ `
566. 
     
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     
568.     int width, int height, int timestamp)
     
569. {
     6 Y) v* f' f1 d- l- ], r- \. I
570.     ASS_Image *subtitles;
     
571.     int detect_change;
     1 v9 }" o9 P4 J) J0 N
572.     uint8_t subtitle_pixel;
     & c+ i! @, X0 w, i* F( {
573.     int x, y;
     $ S3 |/ ?0 |) e) S! w
574.     uint8_t *frame_ptr;
     / U# ^9 }! Z# R& c7 y
575.     uint8_t *subtitle_ptr;
     4 r6 z9 y, r, e8 \. I" G5 S
576. 
     
577.     /* ask library for the subtitle for this timestamp */
     
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     9 D; _8 p8 m( j3 h1 E
579.         timestamp, &detect_change);
     & B) i7 V! D8 ^+ m/ K9 k+ `, V
580. 
     
581.     /* render the list of subtitles onto the decoded frame */
     
582.     while (subtitles)
     
583.     {
     7 N1 o( p8 e! ^8 l  _
584.         /* palette components are only 6 bits, so shift an extra 2
     
585.          * bits off each component */
     % a, a" r% |/ M8 @. W5 g" }0 W* I: C
586.         subtitle_pixel = find_nearest_color(rbt,
     ; A  ^, p- F1 D3 p  {' Z
587.             (subtitles->color >> 10) & 0xFF,
     ; Y% h$ k* ]: }4 K! q0 `
588.             (subtitles->color >> 18) & 0xFF,
     
589.             (subtitles->color >> 26) & 0xFF);
     1 l& `. S" }; e4 f& v
590.         for (y = 0; y < subtitles->h; y++)
     3 ^0 ?6 Y$ u  N2 G( g/ K
591.         {
     ! ?6 K% Q: N8 o- K- T
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     & K2 R* q4 F. a( E0 A' c& g
595.             {
     
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     ; @* A5 d; [  u- L: Z$ P
597.                     *frame_ptr = subtitle_pixel;
     
598.             }
       y% |# t+ O, n/ a  {( \7 ]7 `* Z
599.         }
     
600.         subtitles = subtitles->next;
     - ~# G' A" V- V# k
601.     }
     
602. }
     
603. 
     : u7 {' ?6 j- E/ q& \$ }! p
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     
605.     int origin_x, int origin_y, int window_width, int window_height)
     ) }& l9 ]6 g" t8 b8 ]% j# U
606. {
     
607.     int i;
     2 k" b. G& z8 R9 o3 a& J( |) S  B! B
608.     int j;
     ( a; ~& f& j. u% v
609.     int scale;
     ; Y3 ^# g+ g* |+ p
610.     int width;
     1 W8 @# E8 {0 z  k. ?
611.     int height;
     
612.     int max_width;
     
613.     int max_height;
     
614.     int frame_x;
     ; ?6 h  A5 |. w' E* s2 ?
615.     int frame_y;
     
616.     int fragment_count;
     
617.     int decoded_size;
     . @* J. k8 N& t+ \/ j6 }/ M) c
618.     uint8_t *decoded_frame;
     . P; e* ?: U7 u& Y3 W6 `' R
619.     int fragment;
     
620.     int fragment_compressed_size;
     
621.     int fragment_decompressed_size;
     
622.     int compression_type;
     ) w( U8 x2 R) D) H$ S6 \
623.     int index;
     
624.     int out_index;
     
625.     get_bits_context gb;
     
626.     int frame_size;
     ; I1 P" E8 u' s7 W
627.     int video_frame_size;
     6 S2 k4 h0 ]1 d6 Q8 J0 c
628.     int audio_frame_size;
     . q0 ?, {$ f2 R- R! S5 L3 c) p& E" {% ]' }
629. 
     
630.     int back_ref_offset_type;
     3 a$ B( s  o4 J, U% l. p* j
631.     int back_ref_offset;
     
632.     int back_ref_length;
     : d# @5 K0 V' D* V
633.     int back_ref_start;
     2 d& V5 }. n. D3 Z+ F
634.     int back_ref_end;
     
635. 
       |& @2 }4 ?! b( I
636.     uint8_t *full_window;
     
637.     int full_window_size;
     
638.     int y;
     & y, J% D# N8 b: T% O) c
639.     int window_top;
       m) m* l3 e# O- T* i* l! Y. _$ q
640.     int window_bottom;
     
641.     int window_left;
     ) v+ k+ |4 o% J% b: p9 M2 _1 t
642.     int window_right;
     # f+ d/ q2 {6 `
643.     int window_size;
     , Y8 G8 U  r+ A3 X  D! F; ]% a( V6 b
644. 
     . v  e# g' A: D
645.     char filename[30];
     
646. 
     
647.     put_bits_context *pb;
     
648. 
     , T) h; i5 ^' _' p, E$ R; t
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     9 Y" K+ ]$ A& F, e/ a
651.     pb = init_put_bits();
     
652. 
     
653.     max_width = 0;
     
654.     max_height = 0;
     3 J: O9 y1 F$ Z( M
655. 
     ' M- ~8 n2 [1 f
656.     for (i = 0; i < rbt->frame_count; i++)
     
657.     {
     
658.         /* read the entire frame (includes audio and video) */
     ; Q7 `& l: ]5 L$ ?3 n) D- }
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     
661.         audio_frame_size = frame_size - video_frame_size;
     5 @- R  G  L4 R# ]
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     , n) R9 u' ~9 `9 V- n0 o
663.         {
     
664.             printf("problem reading frame %d\n", i);
     " X9 @$ X6 C4 {% e
665.             return 0;
     $ i, N- U6 O( i! c& E, Y; W2 O4 ~
666.         }
     2 c% t; @1 M; P$ q7 p, E5 O
667. 
     
668.         scale = rbt->frame_load_buffer[3];
       z+ K7 R' w0 h& |+ z
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     ( O( Y8 S- m5 ~; a/ G8 r
670.         if (max_width < width)
     
671.             max_width = width;
     
672.         if (max_height < height)
     + m# ?- t* a8 z3 y6 l# f* X6 d: w
673.             max_height = height;
     
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     9 q- ?: D3 W( ~- x- T1 T- S
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     ' n& K- `7 Q1 z0 K4 j: {. O3 J
678.         decoded_size = width * height;
     + {% ^: G% j. R6 L/ v4 M
679. 
     
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     
681. 
     8 X  u, Y' a* Z& v
682.         /* decode the frame */
     
683.         decoded_frame = malloc(decoded_size);
     6 i; z  C4 z( y) v" R7 X6 c' B
684.         index = 24;
     6 m1 u# D- Z: L; B' h; D- J. e
685.         out_index = 0;
     : r: E- e3 K  @, H9 i: M* o1 H
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     
687.         {
     
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     + A& h4 i+ N" e# N, {# }
689.             index += 4;
     
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     1 L1 G% ^, U6 ~. F& g; {. ~
691.             index += 4;
     % l4 ^7 I, S' B3 o% y' {
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     
693.             index += 2;
     
694. 
     : w+ E. U( z" r# @- K
695.             if (compression_type == 0)
     
696.             {
     
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     / C' _, e4 V* `) S4 u- J% u4 {
698.                     fragment_compressed_size);
     / }$ ]' r! b$ h3 E3 J4 H5 v) T1 [2 l
699. 
     5 K4 l0 o. N6 p+ i
700.                 while (out_index < fragment_decompressed_size)
     
701.                 {
     
702.                     if (read_bits(&gb, 1))
     : b2 h2 p. p" w3 D7 I8 U  w5 p
703.                     {
     
704.                         /* decode back reference offset type */
     
705.                         back_ref_offset_type = read_bits(&gb, 1);
     1 v7 ]! E+ j: T9 w
706. 
     
707.                         /* back reference offset is 7 or 11 bits */
     1 t2 p3 Y# ~% S! q$ P2 q4 @- a
708.                         back_ref_offset = read_bits(&gb,
     ( d- X: Q7 e( k. Q3 O2 B
709.                             (back_ref_offset_type) ? 7 : 11);
     
710. 
     
711.                         /* get the length of the back reference */
     
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     5 E5 t# W( H# Y4 s. n5 f
713.                         back_ref_start = out_index - back_ref_offset;
     
714.                         back_ref_end = back_ref_start + back_ref_length;
     & E# l, l# N! ~) i8 I& Q( G
715. 
     8 H& u$ U1 ?, O3 h, @2 J% j
716.                         /* copy the back reference, byte by byte */
     3 C+ }$ [( \& W# D- `
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     4 R, h; O5 ?6 v6 @8 t
718.                             decoded_frame[out_index++] = decoded_frame[j];
     4 u) l6 T7 l; d. E! F
719.                     }
     . b8 X, N* {% U1 \1 F( a6 s5 D
720.                     else
     
721.                     {
     
722.                         /* read raw pixel byte */
     , q9 a; [# X' E* V; D4 X  D
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     0 h* ?  `8 V. h3 z5 \: Z
724.                     }
     $ X/ a* }! J% r  e1 j/ q. m4 C: z7 N
725.                 }
     : j; ]" _  a) {0 ?) G6 s$ V  s  S$ ~3 T
726. 
     
727.                 delete_get_bits(&gb);
     ) N, Y/ a7 j' y# M5 {/ A
728.             }
     4 X4 L" {; Z4 @! U, Q, G* t3 n
729. 
     
730.             /* next fragment */
     
731.             index += fragment_compressed_size;
     
732.         }
     
733. 
     6 i" ^4 f8 V% U% |- W9 w9 k& k; b
734.         if (rbt->dump_frames)
     ' Q6 z- K- E9 F% F* s, V
735.         {
     8 a, X; ?! z; @- u8 z
736.             /* dump the original frame */
     ' P* Z- y7 Z9 }5 w! c; `8 m
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     9 P1 B; m  ?6 Z1 L' l$ q
739.         }
       q  S7 k8 a9 x/ x8 z- U( o6 g
740. 
     ' S' |, l$ W" f$ Z( w: E: b
741.         /* transfer the image onto the frame window */
     ) Q3 J4 t1 l! d' ^- ]
742.         memset(full_window, 0xFF, full_window_size);
     3 T3 K9 a; ~4 y' W% _, p7 a
743.         index = 0;
     
744.         for (y = 0; y < height; y++)
     
745.         {
     7 r$ l$ h6 {% B8 [! |
746.             out_index = window_width * (frame_y + y) + frame_x;
     
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
     3 s+ h; Y# x4 H/ z
748.             index += width;
     
749.         }
     . L, T9 \. E# o+ ~' a
750. 
     $ k, g8 L; F% i) O3 i% `' @
751.         /* write the subtitle */
     
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     & p  S3 J" ^: v1 O! I
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     % P6 H& H. T, k" u% u
755.         /* figure out the smallest change window */
     1 `, p% t$ w  [6 \0 Z
756.         window_top = frame_y;
     
757.         window_bottom = window_height;
     4 W# l* N0 f$ S0 O% G
758.         window_left = 0;
     & X! ?5 a8 T' C6 b3 \
759.         window_right = window_width;
     
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     
761. 
     
762.         /* compress the frame */
     
763.         reset_put_bits(pb);
     
764.         compress_window(pb, full_window, window_width, window_top,
     , K/ P% Z6 i2 C$ V
765.             window_bottom, window_left, window_right);
     
766. 
     / R! y2 m7 V( N* N
767.         if (rbt->dump_frames)
     , z4 b( W+ }- P
768.         {
     
769.             /* dump the frame plotted onto the full window prior to encoding,
     
770.              * with subtitle */
       w: ~) A2 K- D# s' V# K9 E. v+ F
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     
773.         }
     
774. 
     
775.         free(decoded_frame);
     
776. 
     
777.         /* update the frame header */
     
778.         /* width */
     
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     / s9 e  ^8 i# X$ g9 R
781.         /* height */
     # T# ~  @4 z  ^
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     
784.         /* origin X */
     
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     
787.         /* origin Y */
     
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     
790.         /* fragment payload size */
     * v: _/ d1 q2 C. |! |1 N
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     $ Q; w' x* F6 l# ?: K  w3 }/ m
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     
793.         /* fragment count (1) */
     ) S6 @6 Q* A1 Q  K8 d" p
794.         rbt->frame_load_buffer[18] = 1;
     
795.         rbt->frame_load_buffer[19] = 0;
     # V1 p* N$ r1 A; [6 {5 {7 g1 W
796. 
     
797.         /* update the fragment header */
     1 m/ M1 y( h7 o8 l6 D3 Z* [8 E, r
798.         /* compressed size */
     ) ^% o4 _- ^3 \% H) z- K
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     
803.         /* decompressed size */
     
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     2 z1 R. e9 w$ V1 l. F" s. {
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     4 c& E0 u) D! c* o5 J
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     
808.         /* compression format 0 */
     
809.         rbt->frame_load_buffer[24 + 8] = 0;
     
810.         rbt->frame_load_buffer[24 + 9] = 0;
     ' S0 ~! h/ M/ Z! W; ^
811. 
     
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     4 T$ ~- {1 d$ _6 C, {
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     
814.         {
     
815.             printf("problem writing frame %d\n", i);
     
816.             return 0;
     : Y1 ~) ]( d+ A
817.         }
     
818. 
     % r2 e; k3 f6 J9 r% [7 l" Q
819.         /* write the new compressed frame data */
     0 _* I6 a$ r2 V' D
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     3 s5 B) ~  u0 c* I# P
821.         {
     7 C- P0 A; _  d
822.             printf("problem writing frame %d\n", i);
     
823.             return 0;
     : K7 C% g* ?7 C- p; Q5 V
824.         }
     
825. 
     : y! j3 V% ^' M4 ~$ ~+ J4 V
826.         /* write the audio data */
     
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     
828.         {
     
829.             printf("problem writing frame %d\n", i);
     9 E3 ^: T: Q( R& N6 a
830.             return 0;
     
831.         }
     
832. 
     , |# z. x8 X! F/ d. ]6 f  B0 H
833.         /* update the table entries */
     4 d' x7 U6 D' P; [" ]5 Q" j
834.         video_frame_size = pb->byte_index + 24 + 10;
     * |: m3 P) S" ?3 ^
835.         frame_size = video_frame_size + audio_frame_size;
     
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     . U6 j8 h0 R. s8 r2 B# o' a3 D
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
       `$ d2 f3 L5 y) `7 {# f* d
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     . r6 J  g( H& x$ T. q) J6 ?
840.     }
     & O+ r. t+ q0 z- q  b
841. 
     
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     
843. 
     3 Z. x0 }$ Y0 n
844.     delete_put_bits(pb);
     2 \# d9 h% |- S; v1 ]
845.     free(full_window);
     / m( g/ ]' A0 |
846. 
     7 S2 }! Y" k8 Y: o& D
847.     return 1;
     
848. }
     
849. 
     , l/ y: r% s- s, m) u( I
850. int main(int argc, char *argv[])
     
851. {
     ) y+ k2 y7 r3 B6 U) e* K
852.     char *subtitle_filename;
     $ Y& n- E0 u1 u& U( G, K. O9 Q0 ]2 ~
853.     FILE *subtitle_file;
     2 ?* j/ n+ m9 Y; e* O" c) w, ?6 j
854.     char *inrbt_filename;
     
855.     FILE *inrbt_file;
     2 S& M) j+ \8 Y$ Q* W
856.     char *outrbt_filename;
     
857.     FILE *outrbt_file;
     ) N' W, b; Y# f* ~' q1 V. z2 z
858.     rbt_dec_context rbt;
     $ ~3 \" I, ?4 j' P; b: I
859.     int origin_x;
     # F7 {" A5 t1 J: L8 {
860.     int origin_y;
     
861.     int window_width;
     " g1 j3 h% }7 m9 g3 ^' ?/ |  Y2 |
862.     int window_height;
     
863. 
     + M5 Z: \! S" C# K8 e% O* J
864.     /* testing the bit functions */
     
865. #if 0
     
866.     int i;
     : `( u+ I0 [, n, D
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     
868.     int bytestream_size = 10;
     
869.     get_bits_context gb;
     4 @" e3 ]% [/ z% g% i
870.     put_bits_context *pb;
     
871.     int bits;
     ; ~& x- T  B% U1 i* c
872. 
     # c9 l6 n. H: G5 d
873.     init_get_bits(&gb, bytestream, bytestream_size);
     
874.     pb = init_put_bits();
     
875. 
     
876.     for (i = 1; i <= 12; i++)
     8 d/ T/ U3 d, J% o8 \
877.     {
     - B; `/ ]& Q( d5 Y
878.         bits = view_bits(&gb, i);
     
879.         printf("view %d bits: %d\n", i, bits);
     ( A7 ?# N, u' g) ~6 e
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     
881.         put_bits(pb, bits, i);
     
882.     }
     ! R' J+ K0 C0 o# a. {% {7 i$ `
883.     put_bits_flush(pb);
     5 T2 D% B1 T# z, d
884. 
     
885.     printf("original bytestream:\n");
     7 |# s+ `9 ]$ d& {0 z; F
886.     for (i = 0; i < bytestream_size; i++)
     1 p; m  p  y5 |5 k- }8 I0 [/ P/ h
887.         printf(" %02X", bytestream[i]);
     : \  `4 X1 t$ k7 x
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     
890.         printf(" %02X", pb->bytes[i]);
     
891.     printf("\n");
     8 N+ R+ N5 i+ }; `& @
892. 
     
893.     delete_get_bits(&gb);
     
894.     free(pb);
     4 g* Y5 g" p: H7 k
895. #endif
     
896. 
     
897.     /* validate the number of arguments */
     
898.     if (argc != 8 && argc != 9)
     $ l- B* m8 A$ i1 o
899.     {
     
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     
901.         return 1;
     7 H2 ^% y( Y' i4 P2 S4 f
902.     }
     ; p0 F4 Z; B# R$ V
903.     subtitle_filename = argv[1];
     
904.     inrbt_filename = argv[2];
     6 K! h% E2 g6 b/ @0 e, Q- V
905.     outrbt_filename = argv[3];
     ' {* N2 x+ E& _& O
906.     origin_x = atoi(argv[4]);
     
907.     origin_y = atoi(argv[5]);
     
908.     window_width = atoi(argv[6]);
     * P% ]' _9 r1 V6 R' n
909.     window_height = atoi(argv[7]);
     
910.     rbt.dump_frames = 0;
     . L) H5 p' H: K
911.     if (argc == 9)
     : S0 n. @: L+ N' s3 ^0 F
912.         rbt.dump_frames = 1;
     & @4 O: s# [) R2 W" Z7 e+ `
913. 
     
914.     /* verify that the specified input files are valid */
     6 Y+ ]( o* |8 h2 y5 i# x) Q
915.     subtitle_file = fopen(subtitle_filename, "r");
       u1 X% D& v* }9 L
916.     if (!subtitle_file)
     
917.     {
     
918.         perror(subtitle_filename);
     ! i6 F! I4 _- q6 p. H; `
919.         return 1;
     ' e5 e. z% [) f" b
920.     }
     % F- V, D8 e$ e9 r* j' z
921.     fclose(subtitle_file);
     
922.     inrbt_file = fopen(inrbt_filename, "rb");
     % J7 K! S0 @' g: g. W/ [0 C% C
923.     if (!inrbt_file)
     ! a2 }* _. {! ~7 O) M$ \% J
924.     {
     ' h/ x+ j% S* j1 V# g$ @
925.         perror(inrbt_filename);
     % }% n, a& f  L- x# j9 K4 P
926.         return 1;
     6 r: m# c% g3 u/ H$ ?; K
927.     }
     " C3 B( k/ D( g7 J$ r* ?2 Q
928. 
     
929.     /* initialize the subtitle support */
     7 Q7 j7 @) k8 s  D. ^7 ]
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     - i* ^1 H5 a% w# h1 i
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     9 z4 o/ H1 P: q! f& i
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     - \+ L# y$ J3 E" R) {
935. 
     ( P3 `' K1 ~5 P& C$ ^8 N2 l! Y/ M% W
936.     /* open the output file */
     
937.     outrbt_file = fopen(outrbt_filename, "wb");
     3 U2 z1 u, v3 Q8 R" J
938.     if (!outrbt_file)
     
939.     {
     - ]8 D  F  x' B/ N/ H
940.         perror(outrbt_filename);
     % v% p- [' ?$ s
941.         return 1;
     4 b! Z. v/ f, T) {7 T' H& a1 V
942.     }
     2 x' ~& c8 E. ]7 b) C
943. 
     4 ~1 ^1 V1 }  R. D
944.     /* transfer header from input to output */
     ' l. I: Z& y& T" {4 r1 S  s
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     6 N: J' k! |: m5 s; q
946.         return 1;
     
947. 
     : |0 ^) Z4 R& L# u; b8 N, {0 w" M* B
948.     /* rewrite the frames */
     ! W& L, k( i! z9 R% E' A0 U
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     - }! s# H. b6 a* T
950.         window_width, window_height))
     
951.         return 1;
     ( C+ ]/ C* {/ p  x0 y
952. 
     
953.     /* write the modified frame size tables back to the file */
       ^; j( H! X6 |* A1 A+ x9 X1 B
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     8 ]2 }( E1 w4 k- T
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     ) H; Y8 t2 D2 w
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     9 w( `0 X$ D& K+ L
958. 
     
959.     /* finished with files */
     ' d; \" B0 Y: X6 o9 J) V
960.     fclose(inrbt_file);
     # ^  n# W, P+ T& c  P( c
961.     fclose(outrbt_file);
     
962. 
     5 q8 ^' _$ ~# h
963.     /* clean up subtitle library */
     
964.     ass_free_track(rbt.ass_track);
     : T4 c8 t0 g$ d* P1 c/ e5 w% O$ o2 F
965.     ass_renderer_done(rbt.ass_renderer);
     3 \( Q/ A: U# C2 e/ l8 z! e
966.     ass_library_done(rbt.ass_lib);
     1 U% f# Z; @4 Q9 a% b, `% n
967. 
     % _- R1 G4 O8 G$ @0 G) L
968.     /* clean up */
     
969.     free(rbt.frame_load_buffer);
     
970.     free(rbt.video_frame_size_table);
     
971.     free(rbt.frame_size_table);
     - ?7 c# P( w) [4 j; Q- U. S8 x
972. 
     
973.     return 0;
     6 G& f' e/ ^6 [% b! x7 o3 h3 D9 E: N
974. }

复制代码

' b  M5 P' r+ ?' i1 H

4 K- d0 R. H% y2 h- f# w

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
这游戏有字幕吗？

好像没有字幕，我说的是给视频外挂字幕方式的汉化。
9 u& U& G3 r% E! m- c! G" x# z就像syberia2汉化版下面那行字一样。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
! q: K1 k, `. v# b: Z2 I& f我记得是没字幕的 比较麻烦 都是视频的

给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来